home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / bdb.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  15KB  |  629 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import sys
  5. import os
  6. import types
  7. __all__ = [
  8.     'BdbQuit',
  9.     'Bdb',
  10.     'Breakpoint']
  11.  
  12. class BdbQuit(Exception):
  13.     pass
  14.  
  15.  
  16. class Bdb:
  17.     
  18.     def __init__(self):
  19.         self.breaks = { }
  20.         self.fncache = { }
  21.  
  22.     
  23.     def canonic(self, filename):
  24.         if filename == '<' + filename[1:-1] + '>':
  25.             return filename
  26.         
  27.         canonic = self.fncache.get(filename)
  28.         if not canonic:
  29.             canonic = os.path.abspath(filename)
  30.             canonic = os.path.normcase(canonic)
  31.             self.fncache[filename] = canonic
  32.         
  33.         return canonic
  34.  
  35.     
  36.     def reset(self):
  37.         import linecache as linecache
  38.         linecache.checkcache()
  39.         self.botframe = None
  40.         self.stopframe = None
  41.         self.returnframe = None
  42.         self.quitting = 0
  43.  
  44.     
  45.     def trace_dispatch(self, frame, event, arg):
  46.         if self.quitting:
  47.             return None
  48.         
  49.         if event == 'line':
  50.             return self.dispatch_line(frame)
  51.         
  52.         if event == 'call':
  53.             return self.dispatch_call(frame, arg)
  54.         
  55.         if event == 'return':
  56.             return self.dispatch_return(frame, arg)
  57.         
  58.         if event == 'exception':
  59.             return self.dispatch_exception(frame, arg)
  60.         
  61.         if event == 'c_call':
  62.             return self.trace_dispatch
  63.         
  64.         if event == 'c_exception':
  65.             return self.trace_dispatch
  66.         
  67.         if event == 'c_return':
  68.             return self.trace_dispatch
  69.         
  70.         print 'bdb.Bdb.dispatch: unknown debugging event:', repr(event)
  71.         return self.trace_dispatch
  72.  
  73.     
  74.     def dispatch_line(self, frame):
  75.         if self.stop_here(frame) or self.break_here(frame):
  76.             self.user_line(frame)
  77.             if self.quitting:
  78.                 raise BdbQuit
  79.             
  80.         
  81.         return self.trace_dispatch
  82.  
  83.     
  84.     def dispatch_call(self, frame, arg):
  85.         if self.botframe is None:
  86.             self.botframe = frame.f_back
  87.             return self.trace_dispatch
  88.         
  89.         if not self.stop_here(frame) or self.break_anywhere(frame):
  90.             return None
  91.         
  92.         self.user_call(frame, arg)
  93.         if self.quitting:
  94.             raise BdbQuit
  95.         
  96.         return self.trace_dispatch
  97.  
  98.     
  99.     def dispatch_return(self, frame, arg):
  100.         if self.stop_here(frame) or frame == self.returnframe:
  101.             self.user_return(frame, arg)
  102.             if self.quitting:
  103.                 raise BdbQuit
  104.             
  105.         
  106.         return self.trace_dispatch
  107.  
  108.     
  109.     def dispatch_exception(self, frame, arg):
  110.         if self.stop_here(frame):
  111.             self.user_exception(frame, arg)
  112.             if self.quitting:
  113.                 raise BdbQuit
  114.             
  115.         
  116.         return self.trace_dispatch
  117.  
  118.     
  119.     def stop_here(self, frame):
  120.         if frame is self.stopframe:
  121.             return True
  122.         
  123.         while frame is not None and frame is not self.stopframe:
  124.             if frame is self.botframe:
  125.                 return True
  126.             
  127.             frame = frame.f_back
  128.         return False
  129.  
  130.     
  131.     def break_here(self, frame):
  132.         filename = self.canonic(frame.f_code.co_filename)
  133.         if filename not in self.breaks:
  134.             return False
  135.         
  136.         lineno = frame.f_lineno
  137.         if lineno not in self.breaks[filename]:
  138.             lineno = frame.f_code.co_firstlineno
  139.             if lineno not in self.breaks[filename]:
  140.                 return False
  141.             
  142.         
  143.         (bp, flag) = effective(filename, lineno, frame)
  144.         if bp:
  145.             self.currentbp = bp.number
  146.             if flag and bp.temporary:
  147.                 self.do_clear(str(bp.number))
  148.             
  149.             return True
  150.         else:
  151.             return False
  152.  
  153.     
  154.     def do_clear(self, arg):
  155.         raise NotImplementedError, 'subclass of bdb must implement do_clear()'
  156.  
  157.     
  158.     def break_anywhere(self, frame):
  159.         return self.breaks.has_key(self.canonic(frame.f_code.co_filename))
  160.  
  161.     
  162.     def user_call(self, frame, argument_list):
  163.         pass
  164.  
  165.     
  166.     def user_line(self, frame):
  167.         pass
  168.  
  169.     
  170.     def user_return(self, frame, return_value):
  171.         pass
  172.  
  173.     
  174.     def user_exception(self, frame, .2):
  175.         (exc_type, exc_value, exc_traceback) = .2
  176.  
  177.     
  178.     def set_step(self):
  179.         self.stopframe = None
  180.         self.returnframe = None
  181.         self.quitting = 0
  182.  
  183.     
  184.     def set_next(self, frame):
  185.         self.stopframe = frame
  186.         self.returnframe = None
  187.         self.quitting = 0
  188.  
  189.     
  190.     def set_return(self, frame):
  191.         self.stopframe = frame.f_back
  192.         self.returnframe = frame
  193.         self.quitting = 0
  194.  
  195.     
  196.     def set_trace(self, frame = None):
  197.         if frame is None:
  198.             frame = sys._getframe().f_back
  199.         
  200.         self.reset()
  201.         while frame:
  202.             frame.f_trace = self.trace_dispatch
  203.             self.botframe = frame
  204.             frame = frame.f_back
  205.         self.set_step()
  206.         sys.settrace(self.trace_dispatch)
  207.  
  208.     
  209.     def set_continue(self):
  210.         self.stopframe = self.botframe
  211.         self.returnframe = None
  212.         self.quitting = 0
  213.         if not self.breaks:
  214.             sys.settrace(None)
  215.             frame = sys._getframe().f_back
  216.             while frame and frame is not self.botframe:
  217.                 del frame.f_trace
  218.                 frame = frame.f_back
  219.         
  220.  
  221.     
  222.     def set_quit(self):
  223.         self.stopframe = self.botframe
  224.         self.returnframe = None
  225.         self.quitting = 1
  226.         sys.settrace(None)
  227.  
  228.     
  229.     def set_break(self, filename, lineno, temporary = 0, cond = None, funcname = None):
  230.         filename = self.canonic(filename)
  231.         import linecache
  232.         line = linecache.getline(filename, lineno)
  233.         if not line:
  234.             return 'Line %s:%d does not exist' % (filename, lineno)
  235.         
  236.         if filename not in self.breaks:
  237.             self.breaks[filename] = []
  238.         
  239.         list = self.breaks[filename]
  240.         if lineno not in list:
  241.             list.append(lineno)
  242.         
  243.         bp = Breakpoint(filename, lineno, temporary, cond, funcname)
  244.  
  245.     
  246.     def clear_break(self, filename, lineno):
  247.         filename = self.canonic(filename)
  248.         if filename not in self.breaks:
  249.             return 'There are no breakpoints in %s' % filename
  250.         
  251.         if lineno not in self.breaks[filename]:
  252.             return 'There is no breakpoint at %s:%d' % (filename, lineno)
  253.         
  254.         for bp in Breakpoint.bplist[(filename, lineno)][:]:
  255.             bp.deleteMe()
  256.         
  257.         if not Breakpoint.bplist.has_key((filename, lineno)):
  258.             self.breaks[filename].remove(lineno)
  259.         
  260.         if not self.breaks[filename]:
  261.             del self.breaks[filename]
  262.         
  263.  
  264.     
  265.     def clear_bpbynumber(self, arg):
  266.         
  267.         try:
  268.             number = int(arg)
  269.         except:
  270.             return 'Non-numeric breakpoint number (%s)' % arg
  271.  
  272.         
  273.         try:
  274.             bp = Breakpoint.bpbynumber[number]
  275.         except IndexError:
  276.             return 'Breakpoint number (%d) out of range' % number
  277.  
  278.         if not bp:
  279.             return 'Breakpoint (%d) already deleted' % number
  280.         
  281.         self.clear_break(bp.file, bp.line)
  282.  
  283.     
  284.     def clear_all_file_breaks(self, filename):
  285.         filename = self.canonic(filename)
  286.         if filename not in self.breaks:
  287.             return 'There are no breakpoints in %s' % filename
  288.         
  289.         for line in self.breaks[filename]:
  290.             blist = Breakpoint.bplist[(filename, line)]
  291.             for bp in blist:
  292.                 bp.deleteMe()
  293.             
  294.         
  295.         del self.breaks[filename]
  296.  
  297.     
  298.     def clear_all_breaks(self):
  299.         if not self.breaks:
  300.             return 'There are no breakpoints'
  301.         
  302.         for bp in Breakpoint.bpbynumber:
  303.             if bp:
  304.                 bp.deleteMe()
  305.                 continue
  306.         
  307.         self.breaks = { }
  308.  
  309.     
  310.     def get_break(self, filename, lineno):
  311.         filename = self.canonic(filename)
  312.         if filename in self.breaks:
  313.             pass
  314.         return lineno in self.breaks[filename]
  315.  
  316.     
  317.     def get_breaks(self, filename, lineno):
  318.         filename = self.canonic(filename)
  319.         if not filename in self.breaks and lineno in self.breaks[filename] or Breakpoint.bplist[(filename, lineno)]:
  320.             pass
  321.         return []
  322.  
  323.     
  324.     def get_file_breaks(self, filename):
  325.         filename = self.canonic(filename)
  326.         if filename in self.breaks:
  327.             return self.breaks[filename]
  328.         else:
  329.             return []
  330.  
  331.     
  332.     def get_all_breaks(self):
  333.         return self.breaks
  334.  
  335.     
  336.     def get_stack(self, f, t):
  337.         stack = []
  338.         if t and t.tb_frame is f:
  339.             t = t.tb_next
  340.         
  341.         while f is not None:
  342.             stack.append((f, f.f_lineno))
  343.             if f is self.botframe:
  344.                 break
  345.             
  346.             f = f.f_back
  347.         stack.reverse()
  348.         i = max(0, len(stack) - 1)
  349.         while t is not None:
  350.             stack.append((t.tb_frame, t.tb_lineno))
  351.             t = t.tb_next
  352.         return (stack, i)
  353.  
  354.     
  355.     def format_stack_entry(self, frame_lineno, lprefix = ': '):
  356.         import linecache
  357.         import repr
  358.         (frame, lineno) = frame_lineno
  359.         filename = self.canonic(frame.f_code.co_filename)
  360.         s = '%s(%r)' % (filename, lineno)
  361.         if frame.f_code.co_name:
  362.             s = s + frame.f_code.co_name
  363.         else:
  364.             s = s + '<lambda>'
  365.         if '__args__' in frame.f_locals:
  366.             args = frame.f_locals['__args__']
  367.         else:
  368.             args = None
  369.         if args:
  370.             s = s + repr.repr(args)
  371.         else:
  372.             s = s + '()'
  373.         if '__return__' in frame.f_locals:
  374.             rv = frame.f_locals['__return__']
  375.             s = s + '->'
  376.             s = s + repr.repr(rv)
  377.         
  378.         line = linecache.getline(filename, lineno)
  379.         if line:
  380.             s = s + lprefix + line.strip()
  381.         
  382.         return s
  383.  
  384.     
  385.     def run(self, cmd, globals = None, locals = None):
  386.         if globals is None:
  387.             import __main__ as __main__
  388.             globals = __main__.__dict__
  389.         
  390.         if locals is None:
  391.             locals = globals
  392.         
  393.         self.reset()
  394.         sys.settrace(self.trace_dispatch)
  395.         if not isinstance(cmd, types.CodeType):
  396.             cmd = cmd + '\n'
  397.         
  398.         
  399.         try:
  400.             exec cmd in globals, locals
  401.         except BdbQuit:
  402.             pass
  403.         finally:
  404.             self.quitting = 1
  405.             sys.settrace(None)
  406.  
  407.  
  408.     
  409.     def runeval(self, expr, globals = None, locals = None):
  410.         if globals is None:
  411.             import __main__
  412.             globals = __main__.__dict__
  413.         
  414.         if locals is None:
  415.             locals = globals
  416.         
  417.         self.reset()
  418.         sys.settrace(self.trace_dispatch)
  419.         if not isinstance(expr, types.CodeType):
  420.             expr = expr + '\n'
  421.         
  422.         
  423.         try:
  424.             return eval(expr, globals, locals)
  425.         except BdbQuit:
  426.             pass
  427.         finally:
  428.             self.quitting = 1
  429.             sys.settrace(None)
  430.  
  431.  
  432.     
  433.     def runctx(self, cmd, globals, locals):
  434.         self.run(cmd, globals, locals)
  435.  
  436.     
  437.     def runcall(self, func, *args, **kwds):
  438.         self.reset()
  439.         sys.settrace(self.trace_dispatch)
  440.         res = None
  441.         
  442.         try:
  443.             res = func(*args, **kwds)
  444.         except BdbQuit:
  445.             pass
  446.         finally:
  447.             self.quitting = 1
  448.             sys.settrace(None)
  449.  
  450.         return res
  451.  
  452.  
  453.  
  454. def set_trace():
  455.     Bdb().set_trace()
  456.  
  457.  
  458. class Breakpoint:
  459.     next = 1
  460.     bplist = { }
  461.     bpbynumber = [
  462.         None]
  463.     
  464.     def __init__(self, file, line, temporary = 0, cond = None, funcname = None):
  465.         self.funcname = funcname
  466.         self.func_first_executable_line = None
  467.         self.file = file
  468.         self.line = line
  469.         self.temporary = temporary
  470.         self.cond = cond
  471.         self.enabled = 1
  472.         self.ignore = 0
  473.         self.hits = 0
  474.         self.number = Breakpoint.next
  475.         Breakpoint.next = Breakpoint.next + 1
  476.         self.bpbynumber.append(self)
  477.         if self.bplist.has_key((file, line)):
  478.             self.bplist[(file, line)].append(self)
  479.         else:
  480.             self.bplist[(file, line)] = [
  481.                 self]
  482.  
  483.     
  484.     def deleteMe(self):
  485.         index = (self.file, self.line)
  486.         self.bpbynumber[self.number] = None
  487.         self.bplist[index].remove(self)
  488.         if not self.bplist[index]:
  489.             del self.bplist[index]
  490.         
  491.  
  492.     
  493.     def enable(self):
  494.         self.enabled = 1
  495.  
  496.     
  497.     def disable(self):
  498.         self.enabled = 0
  499.  
  500.     
  501.     def bpprint(self, out = None):
  502.         if out is None:
  503.             out = sys.stdout
  504.         
  505.         if self.temporary:
  506.             disp = 'del  '
  507.         else:
  508.             disp = 'keep '
  509.         if self.enabled:
  510.             disp = disp + 'yes  '
  511.         else:
  512.             disp = disp + 'no   '
  513.         print >>out, '%-4dbreakpoint   %s at %s:%d' % (self.number, disp, self.file, self.line)
  514.         if self.cond:
  515.             print >>out, '\tstop only if %s' % (self.cond,)
  516.         
  517.         if self.ignore:
  518.             print >>out, '\tignore next %d hits' % self.ignore
  519.         
  520.         if self.hits:
  521.             if self.hits > 1:
  522.                 ss = 's'
  523.             else:
  524.                 ss = ''
  525.             print >>out, '\tbreakpoint already hit %d time%s' % (self.hits, ss)
  526.         
  527.  
  528.  
  529.  
  530. def checkfuncname(b, frame):
  531.     if not b.funcname:
  532.         if b.line != frame.f_lineno:
  533.             return False
  534.         
  535.         return True
  536.     
  537.     if frame.f_code.co_name != b.funcname:
  538.         return False
  539.     
  540.     if not b.func_first_executable_line:
  541.         b.func_first_executable_line = frame.f_lineno
  542.     
  543.     if b.func_first_executable_line != frame.f_lineno:
  544.         return False
  545.     
  546.     return True
  547.  
  548.  
  549. def effective(file, line, frame):
  550.     possibles = Breakpoint.bplist[(file, line)]
  551.     for i in range(0, len(possibles)):
  552.         b = possibles[i]
  553.         if b.enabled == 0:
  554.             continue
  555.         
  556.         if not checkfuncname(b, frame):
  557.             continue
  558.         
  559.         b.hits = b.hits + 1
  560.         if not b.cond:
  561.             if b.ignore > 0:
  562.                 b.ignore = b.ignore - 1
  563.                 continue
  564.             else:
  565.                 return (b, 1)
  566.         b.ignore > 0
  567.         
  568.         try:
  569.             val = eval(b.cond, frame.f_globals, frame.f_locals)
  570.             if val:
  571.                 if b.ignore > 0:
  572.                     b.ignore = b.ignore - 1
  573.                 else:
  574.                     return (b, 1)
  575.         continue
  576.         return (b, 0)
  577.         continue
  578.  
  579.     
  580.     return (None, None)
  581.  
  582.  
  583. class Tdb(Bdb):
  584.     
  585.     def user_call(self, frame, args):
  586.         name = frame.f_code.co_name
  587.         if not name:
  588.             name = '???'
  589.         
  590.         print '+++ call', name, args
  591.  
  592.     
  593.     def user_line(self, frame):
  594.         import linecache
  595.         name = frame.f_code.co_name
  596.         if not name:
  597.             name = '???'
  598.         
  599.         fn = self.canonic(frame.f_code.co_filename)
  600.         line = linecache.getline(fn, frame.f_lineno)
  601.         print '+++', fn, frame.f_lineno, name, ':', line.strip()
  602.  
  603.     
  604.     def user_return(self, frame, retval):
  605.         print '+++ return', retval
  606.  
  607.     
  608.     def user_exception(self, frame, exc_stuff):
  609.         print '+++ exception', exc_stuff
  610.         self.set_continue()
  611.  
  612.  
  613.  
  614. def foo(n):
  615.     print 'foo(', n, ')'
  616.     x = bar(n * 10)
  617.     print 'bar returned', x
  618.  
  619.  
  620. def bar(a):
  621.     print 'bar(', a, ')'
  622.     return a / 2
  623.  
  624.  
  625. def test():
  626.     t = Tdb()
  627.     t.run('import bdb; bdb.foo(10)')
  628.  
  629.